home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / sre_compile.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  11KB  |  497 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. from sre_constants import *
  8. if not _sre.MAGIC == MAGIC:
  9.     raise AssertionError, 'SRE module mismatch'
  10. if _sre.CODESIZE == 2:
  11.     MAXCODE = 65535
  12. else:
  13.     MAXCODE = 0xFFFFFFFFL
  14.  
  15. def _identityfunction(x):
  16.     return x
  17.  
  18.  
  19. def set(seq):
  20.     s = { }
  21.     for elem in seq:
  22.         s[elem] = 1
  23.     
  24.     return s
  25.  
  26. _LITERAL_CODES = set([
  27.     LITERAL,
  28.     NOT_LITERAL])
  29. _REPEATING_CODES = set([
  30.     REPEAT,
  31.     MIN_REPEAT,
  32.     MAX_REPEAT])
  33. _SUCCESS_CODES = set([
  34.     SUCCESS,
  35.     FAILURE])
  36. _ASSERT_CODES = set([
  37.     ASSERT,
  38.     ASSERT_NOT])
  39.  
  40. def _compile(code, pattern, flags):
  41.     emit = code.append
  42.     _len = len
  43.     LITERAL_CODES = _LITERAL_CODES
  44.     REPEATING_CODES = _REPEATING_CODES
  45.     SUCCESS_CODES = _SUCCESS_CODES
  46.     ASSERT_CODES = _ASSERT_CODES
  47.     for op, av in pattern:
  48.         if op in LITERAL_CODES:
  49.             if flags & SRE_FLAG_IGNORECASE:
  50.                 emit(OPCODES[OP_IGNORE[op]])
  51.                 emit(_sre.getlower(av, flags))
  52.             else:
  53.                 emit(OPCODES[op])
  54.                 emit(av)
  55.         flags & SRE_FLAG_IGNORECASE
  56.         None if op is IN else flags & SRE_FLAG_DOTALL
  57.         if op in REPEATING_CODES:
  58.             if flags & SRE_FLAG_TEMPLATE:
  59.                 raise error, 'internal: unsupported template operator'
  60.                 emit(OPCODES[REPEAT])
  61.                 skip = _len(code)
  62.                 emit(0)
  63.                 emit(av[0])
  64.                 emit(av[1])
  65.                 _compile(code, av[2], flags)
  66.                 emit(OPCODES[SUCCESS])
  67.                 code[skip] = _len(code) - skip
  68.             elif _simple(av) and op is not REPEAT:
  69.                 if op is MAX_REPEAT:
  70.                     emit(OPCODES[REPEAT_ONE])
  71.                 else:
  72.                     emit(OPCODES[MIN_REPEAT_ONE])
  73.                 skip = _len(code)
  74.                 emit(0)
  75.                 emit(av[0])
  76.                 emit(av[1])
  77.                 _compile(code, av[2], flags)
  78.                 emit(OPCODES[SUCCESS])
  79.                 code[skip] = _len(code) - skip
  80.             else:
  81.                 emit(OPCODES[REPEAT])
  82.                 skip = _len(code)
  83.                 emit(0)
  84.                 emit(av[0])
  85.                 emit(av[1])
  86.                 _compile(code, av[2], flags)
  87.                 code[skip] = _len(code) - skip
  88.                 if op is MAX_REPEAT:
  89.                     emit(OPCODES[MAX_UNTIL])
  90.                 else:
  91.                     emit(OPCODES[MIN_UNTIL])
  92.         op is MAX_REPEAT
  93.         if op is SUBPATTERN:
  94.             if av[0]:
  95.                 emit(OPCODES[MARK])
  96.                 emit((av[0] - 1) * 2)
  97.             
  98.             _compile(code, av[1], flags)
  99.             if av[0]:
  100.                 emit(OPCODES[MARK])
  101.                 emit((av[0] - 1) * 2 + 1)
  102.             
  103.         av[0]
  104.         if op in SUCCESS_CODES:
  105.             emit(OPCODES[op])
  106.             continue
  107.         if op in ASSERT_CODES:
  108.             emit(OPCODES[op])
  109.             skip = _len(code)
  110.             emit(0)
  111.             if av[0] >= 0:
  112.                 emit(0)
  113.             else:
  114.                 (lo, hi) = av[1].getwidth()
  115.                 if lo != hi:
  116.                     raise error, 'look-behind requires fixed-width pattern'
  117.                 
  118.                 emit(lo)
  119.             _compile(code, av[1], flags)
  120.             emit(OPCODES[SUCCESS])
  121.             code[skip] = _len(code) - skip
  122.             continue
  123.         if op is CALL:
  124.             emit(OPCODES[op])
  125.             skip = _len(code)
  126.             emit(0)
  127.             _compile(code, av, flags)
  128.             emit(OPCODES[SUCCESS])
  129.             code[skip] = _len(code) - skip
  130.             continue
  131.         if op is AT:
  132.             emit(OPCODES[op])
  133.             if flags & SRE_FLAG_MULTILINE:
  134.                 av = AT_MULTILINE.get(av, av)
  135.             
  136.             if flags & SRE_FLAG_LOCALE:
  137.                 av = AT_LOCALE.get(av, av)
  138.             elif flags & SRE_FLAG_UNICODE:
  139.                 av = AT_UNICODE.get(av, av)
  140.             
  141.             emit(ATCODES[av])
  142.             continue
  143.         if op is BRANCH:
  144.             emit(OPCODES[op])
  145.             tail = []
  146.             tailappend = tail.append
  147.             for av in av[1]:
  148.                 skip = _len(code)
  149.                 emit(0)
  150.                 _compile(code, av, flags)
  151.                 emit(OPCODES[JUMP])
  152.                 tailappend(_len(code))
  153.                 emit(0)
  154.                 code[skip] = _len(code) - skip
  155.             
  156.             emit(0)
  157.             for tail in tail:
  158.                 code[tail] = _len(code) - tail
  159.             
  160.         if op is CATEGORY:
  161.             emit(OPCODES[op])
  162.             if flags & SRE_FLAG_LOCALE:
  163.                 av = CH_LOCALE[av]
  164.             elif flags & SRE_FLAG_UNICODE:
  165.                 av = CH_UNICODE[av]
  166.             
  167.             emit(CHCODES[av])
  168.             continue
  169.         None if op is GROUPREF else av[2]
  170.         raise ValueError, ('unsupported operand type', op)
  171.     
  172.  
  173.  
  174. def _compile_charset(charset, flags, code, fixup = None):
  175.     emit = code.append
  176.     if fixup is None:
  177.         fixup = _identityfunction
  178.     
  179.     for op, av in _optimize_charset(charset, fixup):
  180.         emit(OPCODES[op])
  181.         if op is NEGATE:
  182.             continue
  183.         if op is LITERAL:
  184.             emit(fixup(av))
  185.             continue
  186.         if op is RANGE:
  187.             emit(fixup(av[0]))
  188.             emit(fixup(av[1]))
  189.             continue
  190.         if op is CHARSET:
  191.             code.extend(av)
  192.             continue
  193.         None if op is BIGCHARSET else flags & SRE_FLAG_LOCALE
  194.         raise error, 'internal: unsupported set operator'
  195.     
  196.     emit(OPCODES[FAILURE])
  197.  
  198.  
  199. def _optimize_charset(charset, fixup):
  200.     out = []
  201.     outappend = out.append
  202.     charmap = [
  203.         0] * 256
  204.     
  205.     try:
  206.         for op, av in charset:
  207.             if op is NEGATE:
  208.                 outappend((op, av))
  209.                 continue
  210.             if op is LITERAL:
  211.                 charmap[fixup(av)] = 1
  212.                 continue
  213.             if op is RANGE:
  214.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  215.                     charmap[i] = 1
  216.                 
  217.             if op is CATEGORY:
  218.                 return charset
  219.                 continue
  220.     except IndexError:
  221.         return _optimize_unicode(charset, fixup)
  222.  
  223.     i = p = n = 0
  224.     runs = []
  225.     runsappend = runs.append
  226.     for c in charmap:
  227.         if c:
  228.             if n == 0:
  229.                 p = i
  230.             
  231.             n = n + 1
  232.         elif n:
  233.             runsappend((p, n))
  234.             n = 0
  235.         
  236.         i = i + 1
  237.     
  238.     if n:
  239.         runsappend((p, n))
  240.     
  241.     if len(runs) <= 2:
  242.         for p, n in runs:
  243.             if n == 1:
  244.                 outappend((LITERAL, p))
  245.                 continue
  246.             outappend((RANGE, (p, p + n - 1)))
  247.         
  248.         if len(out) < len(charset):
  249.             return out
  250.         
  251.     else:
  252.         data = _mk_bitmap(charmap)
  253.         outappend((CHARSET, data))
  254.         return out
  255.     return charset
  256.  
  257.  
  258. def _mk_bitmap(bits):
  259.     data = []
  260.     dataappend = data.append
  261.     if _sre.CODESIZE == 2:
  262.         start = (1, 0)
  263.     else:
  264.         start = (0x1L, 0x0L)
  265.     (m, v) = start
  266.     for c in bits:
  267.         if c:
  268.             v = v + m
  269.         
  270.         m = m + m
  271.         if m > MAXCODE:
  272.             dataappend(v)
  273.             (m, v) = start
  274.             continue
  275.     
  276.     return data
  277.  
  278.  
  279. def _optimize_unicode(charset, fixup):
  280.     
  281.     try:
  282.         import array as array
  283.     except ImportError:
  284.         return charset
  285.  
  286.     charmap = [
  287.         0] * 65536
  288.     negate = 0
  289.     
  290.     try:
  291.         for op, av in charset:
  292.             if op is NEGATE:
  293.                 negate = 1
  294.                 continue
  295.             if op is LITERAL:
  296.                 charmap[fixup(av)] = 1
  297.                 continue
  298.             if op is RANGE:
  299.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  300.                     charmap[i] = 1
  301.                 
  302.             if op is CATEGORY:
  303.                 return charset
  304.                 continue
  305.     except IndexError:
  306.         return charset
  307.  
  308.     if negate:
  309.         if sys.maxunicode != 65535:
  310.             return charset
  311.         
  312.         for i in xrange(65536):
  313.             charmap[i] = not charmap[i]
  314.         
  315.     
  316.     comps = { }
  317.     mapping = [
  318.         0] * 256
  319.     block = 0
  320.     data = []
  321.     for i in xrange(256):
  322.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  323.         new = comps.setdefault(chunk, block)
  324.         mapping[i] = new
  325.         if new == block:
  326.             block = block + 1
  327.             data = data + _mk_bitmap(chunk)
  328.             continue
  329.     
  330.     header = [
  331.         block]
  332.     if _sre.CODESIZE == 2:
  333.         code = 'H'
  334.     else:
  335.         code = 'I'
  336.     mapping = array.array('b', mapping).tostring()
  337.     mapping = array.array(code, mapping)
  338.     if not mapping.itemsize == _sre.CODESIZE:
  339.         raise AssertionError
  340.     header = header + mapping.tolist()
  341.     data[0:0] = header
  342.     return [
  343.         (BIGCHARSET, data)]
  344.  
  345.  
  346. def _simple(av):
  347.     (lo, hi) = av[2].getwidth()
  348.     if lo == 0 and hi == MAXREPEAT:
  349.         raise error, 'nothing to repeat'
  350.     
  351.     return None if hi == hi else av[2][0][0] != SUBPATTERN
  352.  
  353.  
  354. def _compile_info(code, pattern, flags):
  355.     (lo, hi) = pattern.getwidth()
  356.     if lo == 0:
  357.         return None
  358.     
  359.     prefix = []
  360.     prefixappend = prefix.append
  361.     prefix_skip = 0
  362.     charset = []
  363.     charsetappend = charset.append
  364.     if not flags & SRE_FLAG_IGNORECASE:
  365.         for op, av in pattern.data:
  366.             None if op is LITERAL else op is LITERAL
  367.             break
  368.         
  369.         if not prefix and pattern.data:
  370.             (op, av) = pattern.data[0]
  371.             if op is SUBPATTERN and av[1]:
  372.                 (op, av) = av[1][0]
  373.                 if op is LITERAL:
  374.                     charsetappend((op, av))
  375.                 elif op is BRANCH:
  376.                     c = []
  377.                     cappend = c.append
  378.                     for p in av[1]:
  379.                         if not p:
  380.                             break
  381.                         
  382.                         (op, av) = p[0]
  383.                         if op is LITERAL:
  384.                             cappend((op, av))
  385.                             continue
  386.                         break
  387.                     else:
  388.                         charset = c
  389.                 
  390.             elif op is BRANCH:
  391.                 c = []
  392.                 cappend = c.append
  393.                 for p in av[1]:
  394.                     if not p:
  395.                         break
  396.                     
  397.                     (op, av) = p[0]
  398.                     if op is LITERAL:
  399.                         cappend((op, av))
  400.                         continue
  401.                     break
  402.                 else:
  403.                     charset = c
  404.             elif op is IN:
  405.                 charset = av
  406.             
  407.         
  408.     
  409.     emit = code.append
  410.     emit(OPCODES[INFO])
  411.     skip = len(code)
  412.     emit(0)
  413.     mask = 0
  414.     if prefix:
  415.         mask = SRE_INFO_PREFIX
  416.         if prefix_skip == prefix_skip:
  417.             pass
  418.         elif prefix_skip == len(pattern.data):
  419.             mask = mask + SRE_INFO_LITERAL
  420.         
  421.     elif charset:
  422.         mask = mask + SRE_INFO_CHARSET
  423.     
  424.     emit(mask)
  425.     if lo < MAXCODE:
  426.         emit(lo)
  427.     else:
  428.         emit(MAXCODE)
  429.         prefix = prefix[:MAXCODE]
  430.     if hi < MAXCODE:
  431.         emit(hi)
  432.     else:
  433.         emit(0)
  434.     if prefix:
  435.         emit(len(prefix))
  436.         emit(prefix_skip)
  437.         code.extend(prefix)
  438.         table = [
  439.             -1] + [
  440.             0] * len(prefix)
  441.         for i in xrange(len(prefix)):
  442.             table[i + 1] = table[i] + 1
  443.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  444.                 table[i + 1] = table[table[i + 1] - 1] + 1
  445.         
  446.         code.extend(table[1:])
  447.     elif charset:
  448.         _compile_charset(charset, flags, code)
  449.     
  450.     code[skip] = len(code) - skip
  451.  
  452.  
  453. try:
  454.     unicode
  455. except NameError:
  456.     STRING_TYPES = (type(''),)
  457.  
  458. STRING_TYPES = (type(''), type(unicode('')))
  459.  
  460. def isstring(obj):
  461.     for tp in STRING_TYPES:
  462.         if isinstance(obj, tp):
  463.             return 1
  464.             continue
  465.     
  466.     return 0
  467.  
  468.  
  469. def _code(p, flags):
  470.     flags = p.pattern.flags | flags
  471.     code = []
  472.     _compile_info(code, p, flags)
  473.     _compile(code, p.data, flags)
  474.     code.append(OPCODES[SUCCESS])
  475.     return code
  476.  
  477.  
  478. def compile(p, flags = 0):
  479.     if isstring(p):
  480.         import sre_parse as sre_parse
  481.         pattern = p
  482.         p = sre_parse.parse(p, flags)
  483.     else:
  484.         pattern = None
  485.     code = _code(p, flags)
  486.     if p.pattern.groups > 100:
  487.         raise AssertionError('sorry, but this version only supports 100 named groups')
  488.     
  489.     groupindex = p.pattern.groupdict
  490.     indexgroup = [
  491.         None] * p.pattern.groups
  492.     for k, i in groupindex.items():
  493.         indexgroup[i] = k
  494.     
  495.     return _sre.compile(pattern, flags | p.pattern.flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  496.  
  497.